/*===---- tgmath.h - Standard header for type generic math ----------------===*\
 *
 * Based on Clang 3.7 - clang/lib/Headers/tgmath.h - Commit 75883618
 * https://github.com/llvm-mirror/clang/blob/75883618c9d91fbabe20350c875fce48f519ada6/lib/Headers/tgmath.h
 *
 * Copyright (c) 2009 Howard Hinnant
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
\*===----------------------------------------------------------------------===*/

#ifndef __TGMATH_H
#define __TGMATH_H

/* C99 7.22 Type-generic math <tgmath.h>. */
#if defined(__cplusplus)
#include <cmath>
#else
#include <math.h>
#endif

/* Type genericity for C++ is handled with overloading in cmath. */
#if !defined(__cplusplus) && !defined(RC_INVOKED)
#include <complex.h>

#define _TG_ATTRSp __attribute__((__overloadable__))
#define _TG_ATTRS __attribute__((__overloadable__, __always_inline__))

// promotion

typedef void _Argument_type_is_not_arithmetic;
static _Argument_type_is_not_arithmetic __tg_promote(...) __attribute__((__unavailable__, __overloadable__));
static double _TG_ATTRSp __tg_promote(int);
static double _TG_ATTRSp __tg_promote(unsigned int);
static double _TG_ATTRSp __tg_promote(long);
static double _TG_ATTRSp __tg_promote(unsigned long);
static double _TG_ATTRSp __tg_promote(long long);
static double _TG_ATTRSp __tg_promote(unsigned long long);
static float _TG_ATTRSp __tg_promote(float);
static double _TG_ATTRSp __tg_promote(double);
static long double _TG_ATTRSp __tg_promote(long double);
static float _Complex _TG_ATTRSp __tg_promote(float _Complex);
static double _Complex _TG_ATTRSp __tg_promote(double _Complex);
static long double _Complex _TG_ATTRSp __tg_promote(long double _Complex);

#define __tg_promote1(__x) (__typeof__(__tg_promote(__x)))
#define __tg_promote2(__x, __y) (__typeof__(__tg_promote(__x) + __tg_promote(__y)))
#define __tg_promote3(__x, __y, __z) (__typeof__(__tg_promote(__x) + __tg_promote(__y) + __tg_promote(__z)))

// acos

static float _TG_ATTRS __tg_acos(float __x) {
    return acosf(__x);
}

static double _TG_ATTRS __tg_acos(double __x) {
    return acos(__x);
}

static long double _TG_ATTRS __tg_acos(long double __x) {
    return acosl(__x);
}

static float _Complex _TG_ATTRS __tg_acos(float _Complex __x) {
    return cacosf(__x);
}

static double _Complex _TG_ATTRS __tg_acos(double _Complex __x) {
    return cacos(__x);
}

static long double _Complex _TG_ATTRS __tg_acos(long double _Complex __x) {
    return cacosl(__x);
}

#undef acos
#define acos(__x) __tg_acos(__tg_promote1((__x))(__x))

// asin

static float _TG_ATTRS __tg_asin(float __x) {
    return asinf(__x);
}

static double _TG_ATTRS __tg_asin(double __x) {
    return asin(__x);
}

static long double _TG_ATTRS __tg_asin(long double __x) {
    return asinl(__x);
}

static float _Complex _TG_ATTRS __tg_asin(float _Complex __x) {
    return casinf(__x);
}

static double _Complex _TG_ATTRS __tg_asin(double _Complex __x) {
    return casin(__x);
}

static long double _Complex _TG_ATTRS __tg_asin(long double _Complex __x) {
    return casinl(__x);
}

#undef asin
#define asin(__x) __tg_asin(__tg_promote1((__x))(__x))

// atan

static float _TG_ATTRS __tg_atan(float __x) {
    return atanf(__x);
}

static double _TG_ATTRS __tg_atan(double __x) {
    return atan(__x);
}

static long double _TG_ATTRS __tg_atan(long double __x) {
    return atanl(__x);
}

static float _Complex _TG_ATTRS __tg_atan(float _Complex __x) {
    return catanf(__x);
}

static double _Complex _TG_ATTRS __tg_atan(double _Complex __x) {
    return catan(__x);
}

static long double _Complex _TG_ATTRS __tg_atan(long double _Complex __x) {
    return catanl(__x);
}

#undef atan
#define atan(__x) __tg_atan(__tg_promote1((__x))(__x))

// acosh

static float _TG_ATTRS __tg_acosh(float __x) {
    return acoshf(__x);
}

static double _TG_ATTRS __tg_acosh(double __x) {
    return acosh(__x);
}

static long double _TG_ATTRS __tg_acosh(long double __x) {
    return acoshl(__x);
}

static float _Complex _TG_ATTRS __tg_acosh(float _Complex __x) {
    return cacoshf(__x);
}

static double _Complex _TG_ATTRS __tg_acosh(double _Complex __x) {
    return cacosh(__x);
}

static long double _Complex _TG_ATTRS __tg_acosh(long double _Complex __x) {
    return cacoshl(__x);
}

#undef acosh
#define acosh(__x) __tg_acosh(__tg_promote1((__x))(__x))

// asinh

static float _TG_ATTRS __tg_asinh(float __x) {
    return asinhf(__x);
}

static double _TG_ATTRS __tg_asinh(double __x) {
    return asinh(__x);
}

static long double _TG_ATTRS __tg_asinh(long double __x) {
    return asinhl(__x);
}

static float _Complex _TG_ATTRS __tg_asinh(float _Complex __x) {
    return casinhf(__x);
}

static double _Complex _TG_ATTRS __tg_asinh(double _Complex __x) {
    return casinh(__x);
}

static long double _Complex _TG_ATTRS __tg_asinh(long double _Complex __x) {
    return casinhl(__x);
}

#undef asinh
#define asinh(__x) __tg_asinh(__tg_promote1((__x))(__x))

// atanh

static float _TG_ATTRS __tg_atanh(float __x) {
    return atanhf(__x);
}

static double _TG_ATTRS __tg_atanh(double __x) {
    return atanh(__x);
}

static long double _TG_ATTRS __tg_atanh(long double __x) {
    return atanhl(__x);
}

static float _Complex _TG_ATTRS __tg_atanh(float _Complex __x) {
    return catanhf(__x);
}

static double _Complex _TG_ATTRS __tg_atanh(double _Complex __x) {
    return catanh(__x);
}

static long double _Complex _TG_ATTRS __tg_atanh(long double _Complex __x) {
    return catanhl(__x);
}

#undef atanh
#define atanh(__x) __tg_atanh(__tg_promote1((__x))(__x))

// cos

static float _TG_ATTRS __tg_cos(float __x) {
    return cosf(__x);
}

static double _TG_ATTRS __tg_cos(double __x) {
    return cos(__x);
}

static long double _TG_ATTRS __tg_cos(long double __x) {
    return cosl(__x);
}

static float _Complex _TG_ATTRS __tg_cos(float _Complex __x) {
    return ccosf(__x);
}

static double _Complex _TG_ATTRS __tg_cos(double _Complex __x) {
    return ccos(__x);
}

static long double _Complex _TG_ATTRS __tg_cos(long double _Complex __x) {
    return ccosl(__x);
}

#undef cos
#define cos(__x) __tg_cos(__tg_promote1((__x))(__x))

// sin

static float _TG_ATTRS __tg_sin(float __x) {
    return sinf(__x);
}

static double _TG_ATTRS __tg_sin(double __x) {
    return sin(__x);
}

static long double _TG_ATTRS __tg_sin(long double __x) {
    return sinl(__x);
}

static float _Complex _TG_ATTRS __tg_sin(float _Complex __x) {
    return csinf(__x);
}

static double _Complex _TG_ATTRS __tg_sin(double _Complex __x) {
    return csin(__x);
}

static long double _Complex _TG_ATTRS __tg_sin(long double _Complex __x) {
    return csinl(__x);
}

#undef sin
#define sin(__x) __tg_sin(__tg_promote1((__x))(__x))

// tan

static float _TG_ATTRS __tg_tan(float __x) {
    return tanf(__x);
}

static double _TG_ATTRS __tg_tan(double __x) {
    return tan(__x);
}

static long double _TG_ATTRS __tg_tan(long double __x) {
    return tanl(__x);
}

static float _Complex _TG_ATTRS __tg_tan(float _Complex __x) {
    return ctanf(__x);
}

static double _Complex _TG_ATTRS __tg_tan(double _Complex __x) {
    return ctan(__x);
}

static long double _Complex _TG_ATTRS __tg_tan(long double _Complex __x) {
    return ctanl(__x);
}

#undef tan
#define tan(__x) __tg_tan(__tg_promote1((__x))(__x))

// cosh

static float _TG_ATTRS __tg_cosh(float __x) {
    return coshf(__x);
}

static double _TG_ATTRS __tg_cosh(double __x) {
    return cosh(__x);
}

static long double _TG_ATTRS __tg_cosh(long double __x) {
    return coshl(__x);
}

static float _Complex _TG_ATTRS __tg_cosh(float _Complex __x) {
    return ccoshf(__x);
}

static double _Complex _TG_ATTRS __tg_cosh(double _Complex __x) {
    return ccosh(__x);
}

static long double _Complex _TG_ATTRS __tg_cosh(long double _Complex __x) {
    return ccoshl(__x);
}

#undef cosh
#define cosh(__x) __tg_cosh(__tg_promote1((__x))(__x))

// sinh

static float _TG_ATTRS __tg_sinh(float __x) {
    return sinhf(__x);
}

static double _TG_ATTRS __tg_sinh(double __x) {
    return sinh(__x);
}

static long double _TG_ATTRS __tg_sinh(long double __x) {
    return sinhl(__x);
}

static float _Complex _TG_ATTRS __tg_sinh(float _Complex __x) {
    return csinhf(__x);
}

static double _Complex _TG_ATTRS __tg_sinh(double _Complex __x) {
    return csinh(__x);
}

static long double _Complex _TG_ATTRS __tg_sinh(long double _Complex __x) {
    return csinhl(__x);
}

#undef sinh
#define sinh(__x) __tg_sinh(__tg_promote1((__x))(__x))

// tanh

static float _TG_ATTRS __tg_tanh(float __x) {
    return tanhf(__x);
}

static double _TG_ATTRS __tg_tanh(double __x) {
    return tanh(__x);
}

static long double _TG_ATTRS __tg_tanh(long double __x) {
    return tanhl(__x);
}

static float _Complex _TG_ATTRS __tg_tanh(float _Complex __x) {
    return ctanhf(__x);
}

static double _Complex _TG_ATTRS __tg_tanh(double _Complex __x) {
    return ctanh(__x);
}

static long double _Complex _TG_ATTRS __tg_tanh(long double _Complex __x) {
    return ctanhl(__x);
}

#undef tanh
#define tanh(__x) __tg_tanh(__tg_promote1((__x))(__x))

// exp

static float _TG_ATTRS __tg_exp(float __x) {
    return expf(__x);
}

static double _TG_ATTRS __tg_exp(double __x) {
    return exp(__x);
}

static long double _TG_ATTRS __tg_exp(long double __x) {
    return expl(__x);
}

static float _Complex _TG_ATTRS __tg_exp(float _Complex __x) {
    return cexpf(__x);
}

static double _Complex _TG_ATTRS __tg_exp(double _Complex __x) {
    return cexp(__x);
}

static long double _Complex _TG_ATTRS __tg_exp(long double _Complex __x) {
    return cexpl(__x);
}

#undef exp
#define exp(__x) __tg_exp(__tg_promote1((__x))(__x))

// log

static float _TG_ATTRS __tg_log(float __x) {
    return logf(__x);
}

static double _TG_ATTRS __tg_log(double __x) {
    return log(__x);
}

static long double _TG_ATTRS __tg_log(long double __x) {
    return logl(__x);
}

static float _Complex _TG_ATTRS __tg_log(float _Complex __x) {
    return clogf(__x);
}

static double _Complex _TG_ATTRS __tg_log(double _Complex __x) {
    return clog(__x);
}

static long double _Complex _TG_ATTRS __tg_log(long double _Complex __x) {
    return clogl(__x);
}

#undef log
#define log(__x) __tg_log(__tg_promote1((__x))(__x))

// pow

static float _TG_ATTRS __tg_pow(float __x, float __y) {
    return powf(__x, __y);
}

static double _TG_ATTRS __tg_pow(double __x, double __y) {
    return pow(__x, __y);
}

static long double _TG_ATTRS __tg_pow(long double __x, long double __y) {
    return powl(__x, __y);
}

static float _Complex _TG_ATTRS __tg_pow(float _Complex __x, float _Complex __y) {
    return cpowf(__x, __y);
}

static double _Complex _TG_ATTRS __tg_pow(double _Complex __x, double _Complex __y) {
    return cpow(__x, __y);
}

static long double _Complex _TG_ATTRS __tg_pow(long double _Complex __x, long double _Complex __y) {
    return cpowl(__x, __y);
}

#undef pow
#define pow(__x, __y) __tg_pow(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))

// sqrt

static float _TG_ATTRS __tg_sqrt(float __x) {
    return sqrtf(__x);
}

static double _TG_ATTRS __tg_sqrt(double __x) {
    return sqrt(__x);
}

static long double _TG_ATTRS __tg_sqrt(long double __x) {
    return sqrtl(__x);
}

static float _Complex _TG_ATTRS __tg_sqrt(float _Complex __x) {
    return csqrtf(__x);
}

static double _Complex _TG_ATTRS __tg_sqrt(double _Complex __x) {
    return csqrt(__x);
}

static long double _Complex _TG_ATTRS __tg_sqrt(long double _Complex __x) {
    return csqrtl(__x);
}

#undef sqrt
#define sqrt(__x) __tg_sqrt(__tg_promote1((__x))(__x))

// fabs

static float _TG_ATTRS __tg_fabs(float __x) {
    return fabsf(__x);
}

static double _TG_ATTRS __tg_fabs(double __x) {
    return fabs(__x);
}

static long double _TG_ATTRS __tg_fabs(long double __x) {
    return fabsl(__x);
}

static float _TG_ATTRS __tg_fabs(float _Complex __x) {
    return cabsf(__x);
}

static double _TG_ATTRS __tg_fabs(double _Complex __x) {
    return cabs(__x);
}

static long double _TG_ATTRS __tg_fabs(long double _Complex __x) {
    return cabsl(__x);
}

#undef fabs
#define fabs(__x) __tg_fabs(__tg_promote1((__x))(__x))

// atan2

static float _TG_ATTRS __tg_atan2(float __x, float __y) {
    return atan2f(__x, __y);
}

static double _TG_ATTRS __tg_atan2(double __x, double __y) {
    return atan2(__x, __y);
}

static long double _TG_ATTRS __tg_atan2(long double __x, long double __y) {
    return atan2l(__x, __y);
}

#undef atan2
#define atan2(__x, __y) __tg_atan2(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))

// cbrt

static float _TG_ATTRS __tg_cbrt(float __x) {
    return cbrtf(__x);
}

static double _TG_ATTRS __tg_cbrt(double __x) {
    return cbrt(__x);
}

static long double _TG_ATTRS __tg_cbrt(long double __x) {
    return cbrtl(__x);
}

#undef cbrt
#define cbrt(__x) __tg_cbrt(__tg_promote1((__x))(__x))

// ceil

static float _TG_ATTRS __tg_ceil(float __x) {
    return ceilf(__x);
}

static double _TG_ATTRS __tg_ceil(double __x) {
    return ceil(__x);
}

static long double _TG_ATTRS __tg_ceil(long double __x) {
    return ceill(__x);
}

#undef ceil
#define ceil(__x) __tg_ceil(__tg_promote1((__x))(__x))

// copysign

static float _TG_ATTRS __tg_copysign(float __x, float __y) {
    return copysignf(__x, __y);
}

static double _TG_ATTRS __tg_copysign(double __x, double __y) {
    return copysign(__x, __y);
}

static long double _TG_ATTRS __tg_copysign(long double __x, long double __y) {
    return copysignl(__x, __y);
}

#undef copysign
#define copysign(__x, __y) __tg_copysign(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))

// erf

static float _TG_ATTRS __tg_erf(float __x) {
    return erff(__x);
}

static double _TG_ATTRS __tg_erf(double __x) {
    return erf(__x);
}

static long double _TG_ATTRS __tg_erf(long double __x) {
    return erfl(__x);
}

#undef erf
#define erf(__x) __tg_erf(__tg_promote1((__x))(__x))

// erfc

static float _TG_ATTRS __tg_erfc(float __x) {
    return erfcf(__x);
}

static double _TG_ATTRS __tg_erfc(double __x) {
    return erfc(__x);
}

static long double _TG_ATTRS __tg_erfc(long double __x) {
    return erfcl(__x);
}

#undef erfc
#define erfc(__x) __tg_erfc(__tg_promote1((__x))(__x))

// exp2

static float _TG_ATTRS __tg_exp2(float __x) {
    return exp2f(__x);
}

static double _TG_ATTRS __tg_exp2(double __x) {
    return exp2(__x);
}

static long double _TG_ATTRS __tg_exp2(long double __x) {
    return exp2l(__x);
}

#undef exp2
#define exp2(__x) __tg_exp2(__tg_promote1((__x))(__x))

// expm1

static float _TG_ATTRS __tg_expm1(float __x) {
    return expm1f(__x);
}

static double _TG_ATTRS __tg_expm1(double __x) {
    return expm1(__x);
}

static long double _TG_ATTRS __tg_expm1(long double __x) {
    return expm1l(__x);
}

#undef expm1
#define expm1(__x) __tg_expm1(__tg_promote1((__x))(__x))

// fdim

static float _TG_ATTRS __tg_fdim(float __x, float __y) {
    return fdimf(__x, __y);
}

static double _TG_ATTRS __tg_fdim(double __x, double __y) {
    return fdim(__x, __y);
}

static long double _TG_ATTRS __tg_fdim(long double __x, long double __y) {
    return fdiml(__x, __y);
}

#undef fdim
#define fdim(__x, __y) __tg_fdim(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))

// floor

static float _TG_ATTRS __tg_floor(float __x) {
    return floorf(__x);
}

static double _TG_ATTRS __tg_floor(double __x) {
    return floor(__x);
}

static long double _TG_ATTRS __tg_floor(long double __x) {
    return floorl(__x);
}

#undef floor
#define floor(__x) __tg_floor(__tg_promote1((__x))(__x))

// fma

static float _TG_ATTRS __tg_fma(float __x, float __y, float __z) {
    return fmaf(__x, __y, __z);
}

static double _TG_ATTRS __tg_fma(double __x, double __y, double __z) {
    return fma(__x, __y, __z);
}

static long double _TG_ATTRS __tg_fma(long double __x, long double __y, long double __z) {
    return fmal(__x, __y, __z);
}

#undef fma
#define fma(__x, __y, __z) \
    __tg_fma(__tg_promote3((__x), (__y), (__z))(__x), __tg_promote3((__x), (__y), (__z))(__y), __tg_promote3((__x), (__y), (__z))(__z))

// fmax

static float _TG_ATTRS __tg_fmax(float __x, float __y) {
    return fmaxf(__x, __y);
}

static double _TG_ATTRS __tg_fmax(double __x, double __y) {
    return fmax(__x, __y);
}

static long double _TG_ATTRS __tg_fmax(long double __x, long double __y) {
    return fmaxl(__x, __y);
}

#undef fmax
#define fmax(__x, __y) __tg_fmax(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))

// fmin

static float _TG_ATTRS __tg_fmin(float __x, float __y) {
    return fminf(__x, __y);
}

static double _TG_ATTRS __tg_fmin(double __x, double __y) {
    return fmin(__x, __y);
}

static long double _TG_ATTRS __tg_fmin(long double __x, long double __y) {
    return fminl(__x, __y);
}

#undef fmin
#define fmin(__x, __y) __tg_fmin(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))

// fmod

static float _TG_ATTRS __tg_fmod(float __x, float __y) {
    return fmodf(__x, __y);
}

static double _TG_ATTRS __tg_fmod(double __x, double __y) {
    return fmod(__x, __y);
}

static long double _TG_ATTRS __tg_fmod(long double __x, long double __y) {
    return fmodl(__x, __y);
}

#undef fmod
#define fmod(__x, __y) __tg_fmod(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))

// frexp

static float _TG_ATTRS __tg_frexp(float __x, int* __y) {
    return frexpf(__x, __y);
}

static double _TG_ATTRS __tg_frexp(double __x, int* __y) {
    return frexp(__x, __y);
}

static long double _TG_ATTRS __tg_frexp(long double __x, int* __y) {
    return frexpl(__x, __y);
}

#undef frexp
#define frexp(__x, __y) __tg_frexp(__tg_promote1((__x))(__x), __y)

// hypot

static float _TG_ATTRS __tg_hypot(float __x, float __y) {
    return hypotf(__x, __y);
}

static double _TG_ATTRS __tg_hypot(double __x, double __y) {
    return hypot(__x, __y);
}

static long double _TG_ATTRS __tg_hypot(long double __x, long double __y) {
    return hypotl(__x, __y);
}

#undef hypot
#define hypot(__x, __y) __tg_hypot(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))

// ilogb

static int _TG_ATTRS __tg_ilogb(float __x) {
    return ilogbf(__x);
}

static int _TG_ATTRS __tg_ilogb(double __x) {
    return ilogb(__x);
}

static int _TG_ATTRS __tg_ilogb(long double __x) {
    return ilogbl(__x);
}

#undef ilogb
#define ilogb(__x) __tg_ilogb(__tg_promote1((__x))(__x))

// ldexp

static float _TG_ATTRS __tg_ldexp(float __x, int __y) {
    return ldexpf(__x, __y);
}

static double _TG_ATTRS __tg_ldexp(double __x, int __y) {
    return ldexp(__x, __y);
}

static long double _TG_ATTRS __tg_ldexp(long double __x, int __y) {
    return ldexpl(__x, __y);
}

#undef ldexp
#define ldexp(__x, __y) __tg_ldexp(__tg_promote1((__x))(__x), __y)

// lgamma

static float _TG_ATTRS __tg_lgamma(float __x) {
    return lgammaf(__x);
}

static double _TG_ATTRS __tg_lgamma(double __x) {
    return lgamma(__x);
}

static long double _TG_ATTRS __tg_lgamma(long double __x) {
    return lgammal(__x);
}

#undef lgamma
#define lgamma(__x) __tg_lgamma(__tg_promote1((__x))(__x))

// llrint

static long long _TG_ATTRS __tg_llrint(float __x) {
    return llrintf(__x);
}

static long long _TG_ATTRS __tg_llrint(double __x) {
    return llrint(__x);
}

static long long _TG_ATTRS __tg_llrint(long double __x) {
    return llrintl(__x);
}

#undef llrint
#define llrint(__x) __tg_llrint(__tg_promote1((__x))(__x))

// llround

static long long _TG_ATTRS __tg_llround(float __x) {
    return llroundf(__x);
}

static long long _TG_ATTRS __tg_llround(double __x) {
    return llround(__x);
}

static long long _TG_ATTRS __tg_llround(long double __x) {
    return llroundl(__x);
}

#undef llround
#define llround(__x) __tg_llround(__tg_promote1((__x))(__x))

// log10

static float _TG_ATTRS __tg_log10(float __x) {
    return log10f(__x);
}

static double _TG_ATTRS __tg_log10(double __x) {
    return log10(__x);
}

static long double _TG_ATTRS __tg_log10(long double __x) {
    return log10l(__x);
}

#undef log10
#define log10(__x) __tg_log10(__tg_promote1((__x))(__x))

// log1p

static float _TG_ATTRS __tg_log1p(float __x) {
    return log1pf(__x);
}

static double _TG_ATTRS __tg_log1p(double __x) {
    return log1p(__x);
}

static long double _TG_ATTRS __tg_log1p(long double __x) {
    return log1pl(__x);
}

#undef log1p
#define log1p(__x) __tg_log1p(__tg_promote1((__x))(__x))

// log2

static float _TG_ATTRS __tg_log2(float __x) {
    return log2f(__x);
}

static double _TG_ATTRS __tg_log2(double __x) {
    return log2(__x);
}

static long double _TG_ATTRS __tg_log2(long double __x) {
    return log2l(__x);
}

#undef log2
#define log2(__x) __tg_log2(__tg_promote1((__x))(__x))

// logb

static float _TG_ATTRS __tg_logb(float __x) {
    return logbf(__x);
}

static double _TG_ATTRS __tg_logb(double __x) {
    return logb(__x);
}

static long double _TG_ATTRS __tg_logb(long double __x) {
    return logbl(__x);
}

#undef logb
#define logb(__x) __tg_logb(__tg_promote1((__x))(__x))

// lrint

static long _TG_ATTRS __tg_lrint(float __x) {
    return lrintf(__x);
}

static long _TG_ATTRS __tg_lrint(double __x) {
    return lrint(__x);
}

static long _TG_ATTRS __tg_lrint(long double __x) {
    return lrintl(__x);
}

#undef lrint
#define lrint(__x) __tg_lrint(__tg_promote1((__x))(__x))

// lround

static long _TG_ATTRS __tg_lround(float __x) {
    return lroundf(__x);
}

static long _TG_ATTRS __tg_lround(double __x) {
    return lround(__x);
}

static long _TG_ATTRS __tg_lround(long double __x) {
    return lroundl(__x);
}

#undef lround
#define lround(__x) __tg_lround(__tg_promote1((__x))(__x))

// nearbyint

static float _TG_ATTRS __tg_nearbyint(float __x) {
    return nearbyintf(__x);
}

static double _TG_ATTRS __tg_nearbyint(double __x) {
    return nearbyint(__x);
}

static long double _TG_ATTRS __tg_nearbyint(long double __x) {
    return nearbyintl(__x);
}

#undef nearbyint
#define nearbyint(__x) __tg_nearbyint(__tg_promote1((__x))(__x))

// nextafter

static float _TG_ATTRS __tg_nextafter(float __x, float __y) {
    return nextafterf(__x, __y);
}

static double _TG_ATTRS __tg_nextafter(double __x, double __y) {
    return nextafter(__x, __y);
}

static long double _TG_ATTRS __tg_nextafter(long double __x, long double __y) {
    return nextafterl(__x, __y);
}

#undef nextafter
#define nextafter(__x, __y) __tg_nextafter(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))

// nexttoward

static float _TG_ATTRS __tg_nexttoward(float __x, long double __y) {
    return nexttowardf(__x, __y);
}

static double _TG_ATTRS __tg_nexttoward(double __x, long double __y) {
    return nexttoward(__x, __y);
}

static long double _TG_ATTRS __tg_nexttoward(long double __x, long double __y) {
    return nexttowardl(__x, __y);
}

#undef nexttoward
#define nexttoward(__x, __y) __tg_nexttoward(__tg_promote1((__x))(__x), (__y))

// remainder

static float _TG_ATTRS __tg_remainder(float __x, float __y) {
    return remainderf(__x, __y);
}

static double _TG_ATTRS __tg_remainder(double __x, double __y) {
    return remainder(__x, __y);
}

static long double _TG_ATTRS __tg_remainder(long double __x, long double __y) {
    return remainderl(__x, __y);
}

#undef remainder
#define remainder(__x, __y) __tg_remainder(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))

// remquo

static float _TG_ATTRS __tg_remquo(float __x, float __y, int* __z) {
    return remquof(__x, __y, __z);
}

static double _TG_ATTRS __tg_remquo(double __x, double __y, int* __z) {
    return remquo(__x, __y, __z);
}

static long double _TG_ATTRS __tg_remquo(long double __x, long double __y, int* __z) {
    return remquol(__x, __y, __z);
}

#undef remquo
#define remquo(__x, __y, __z) __tg_remquo(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y), (__z))

// rint

static float _TG_ATTRS __tg_rint(float __x) {
    return rintf(__x);
}

static double _TG_ATTRS __tg_rint(double __x) {
    return rint(__x);
}

static long double _TG_ATTRS __tg_rint(long double __x) {
    return rintl(__x);
}

#undef rint
#define rint(__x) __tg_rint(__tg_promote1((__x))(__x))

// round

static float _TG_ATTRS __tg_round(float __x) {
    return roundf(__x);
}

static double _TG_ATTRS __tg_round(double __x) {
    return round(__x);
}

static long double _TG_ATTRS __tg_round(long double __x) {
    return roundl(__x);
}

#undef round
#define round(__x) __tg_round(__tg_promote1((__x))(__x))

// scalbn

static float _TG_ATTRS __tg_scalbn(float __x, int __y) {
    return scalbnf(__x, __y);
}

static double _TG_ATTRS __tg_scalbn(double __x, int __y) {
    return scalbn(__x, __y);
}

static long double _TG_ATTRS __tg_scalbn(long double __x, int __y) {
    return scalbnl(__x, __y);
}

#undef scalbn
#define scalbn(__x, __y) __tg_scalbn(__tg_promote1((__x))(__x), __y)

// scalbln

static float _TG_ATTRS __tg_scalbln(float __x, long __y) {
    return scalblnf(__x, __y);
}

static double _TG_ATTRS __tg_scalbln(double __x, long __y) {
    return scalbln(__x, __y);
}

static long double _TG_ATTRS __tg_scalbln(long double __x, long __y) {
    return scalblnl(__x, __y);
}

#undef scalbln
#define scalbln(__x, __y) __tg_scalbln(__tg_promote1((__x))(__x), __y)

// tgamma

static float _TG_ATTRS __tg_tgamma(float __x) {
    return tgammaf(__x);
}

static double _TG_ATTRS __tg_tgamma(double __x) {
    return tgamma(__x);
}

static long double _TG_ATTRS __tg_tgamma(long double __x) {
    return tgammal(__x);
}

#undef tgamma
#define tgamma(__x) __tg_tgamma(__tg_promote1((__x))(__x))

// trunc

static float _TG_ATTRS __tg_trunc(float __x) {
    return truncf(__x);
}

static double _TG_ATTRS __tg_trunc(double __x) {
    return trunc(__x);
}

static long double _TG_ATTRS __tg_trunc(long double __x) {
    return truncl(__x);
}

#undef trunc
#define trunc(__x) __tg_trunc(__tg_promote1((__x))(__x))

// carg

static float _TG_ATTRS __tg_carg(float __x) {
    return atan2f(0.F, __x);
}

static double _TG_ATTRS __tg_carg(double __x) {
    return atan2(0., __x);
}

static long double _TG_ATTRS __tg_carg(long double __x) {
    return atan2l(0.L, __x);
}

static float _TG_ATTRS __tg_carg(float _Complex __x) {
    return cargf(__x);
}

static double _TG_ATTRS __tg_carg(double _Complex __x) {
    return carg(__x);
}

static long double _TG_ATTRS __tg_carg(long double _Complex __x) {
    return cargl(__x);
}

#undef carg
#define carg(__x) __tg_carg(__tg_promote1((__x))(__x))

// cimag

static float _TG_ATTRS __tg_cimag(float __x) {
    return 0;
}

static double _TG_ATTRS __tg_cimag(double __x) {
    return 0;
}

static long double _TG_ATTRS __tg_cimag(long double __x) {
    return 0;
}

static float _TG_ATTRS __tg_cimag(float _Complex __x) {
    return cimagf(__x);
}

static double _TG_ATTRS __tg_cimag(double _Complex __x) {
    return cimag(__x);
}

static long double _TG_ATTRS __tg_cimag(long double _Complex __x) {
    return cimagl(__x);
}

#undef cimag
#define cimag(__x) __tg_cimag(__tg_promote1((__x))(__x))

// conj

static float _Complex _TG_ATTRS __tg_conj(float __x) {
    return __x;
}

static double _Complex _TG_ATTRS __tg_conj(double __x) {
    return __x;
}

static long double _Complex _TG_ATTRS __tg_conj(long double __x) {
    return __x;
}

static float _Complex _TG_ATTRS __tg_conj(float _Complex __x) {
    return conjf(__x);
}

static double _Complex _TG_ATTRS __tg_conj(double _Complex __x) {
    return conj(__x);
}

static long double _Complex _TG_ATTRS __tg_conj(long double _Complex __x) {
    return conjl(__x);
}

#undef conj
#define conj(__x) __tg_conj(__tg_promote1((__x))(__x))

// cproj

static float _Complex _TG_ATTRS __tg_cproj(float __x) {
    return cprojf(__x);
}

static double _Complex _TG_ATTRS __tg_cproj(double __x) {
    return cproj(__x);
}

static long double _Complex _TG_ATTRS __tg_cproj(long double __x) {
    return cprojl(__x);
}

static float _Complex _TG_ATTRS __tg_cproj(float _Complex __x) {
    return cprojf(__x);
}

static double _Complex _TG_ATTRS __tg_cproj(double _Complex __x) {
    return cproj(__x);
}

static long double _Complex _TG_ATTRS __tg_cproj(long double _Complex __x) {
    return cprojl(__x);
}

#undef cproj
#define cproj(__x) __tg_cproj(__tg_promote1((__x))(__x))

// creal

static float _TG_ATTRS __tg_creal(float __x) {
    return __x;
}

static double _TG_ATTRS __tg_creal(double __x) {
    return __x;
}

static long double _TG_ATTRS __tg_creal(long double __x) {
    return __x;
}

static float _TG_ATTRS __tg_creal(float _Complex __x) {
    return crealf(__x);
}

static double _TG_ATTRS __tg_creal(double _Complex __x) {
    return creal(__x);
}

static long double _TG_ATTRS __tg_creal(long double _Complex __x) {
    return creall(__x);
}

#undef creal
#define creal(__x) __tg_creal(__tg_promote1((__x))(__x))

#undef _TG_ATTRSp
#undef _TG_ATTRS

#endif /* !defined(__cplusplus) && !defined(RC_INVOKED) */
#endif /* __TGMATH_H */
